﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using itau.im.relatorios.entidade;
using EnterpriseLibraryWrapper;
using System.Data;

namespace itau.im.relatorios.dado
{
    public class RelatorioCurvaDB : IRelatorioCurvaDAO
    {
        public const string ANTEPOLACAO = "ANTEPOLAÇÃO";
        public const string INTERPOLACAO = "INTERPOLAÇÃO";
        public const string EXTRAPOLACAO = "EXTRAPOLAÇÃO";
        public const string VERTICE = "VERTICE";

        public IList<Curva> ObterCurvas()
        {
            List<Curva> lista = new List<Curva>();
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                DataSet ds = data.ExecuteDataSet("DB2IM.IMSIT");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getCurva(linha));
                    }
                }
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
                lista = null;
            }

            return new List<Curva>();
        }

        public FiltroRelatorioCurva ObterFiltrosRelatorioCurva()
        {
            IDataAccessWrapper data = null;
            FiltroRelatorioCurva filtroRelatorioCurvas = null;
            DataSet ds;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                filtroRelatorioCurvas = EntidadeFactory.getfiltroRelatorioCurvas();

                filtroRelatorioCurvas.Curva.AddRange(ObterCurvas());

                filtroRelatorioCurvas.TipoCurva.AddRange(ObterTiposCurva());

                filtroRelatorioCurvas.SubMesasOperacao.AddRange(ObterSubMesas(1));

                filtroRelatorioCurvas.Modalidade.AddRange(ObterModalidadesCurva());

                return filtroRelatorioCurvas;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }

            return null;
        }

        public IList<TipoCurva> ObterTiposCurva()
        {
            List<TipoCurva> lista = new List<TipoCurva>();
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                DataSet ds = data.ExecuteDataSet("DB2IM.IMSIE");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getTipoCurva(linha));
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }

            return lista;
        }

        public IList<ModalidadeCurva> ObterModalidadesCurva()
        {
            //Declara o objeto
            IList<ModalidadeCurva> lista = new List<ModalidadeCurva>();
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                ds = data.ExecuteDataSet("DB2IM.IMSIF");

                //Verifica se é válido
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre os itens
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Adiciona o item
                        lista.Add(EntidadeFactory.getModalidadeCurva(linha));
                    }
                }
                //Retorna a lista de objetos da consulta
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                lista = null;
                data.Dispose();
                data = null;
                ds = null;

            }

            //Retorna lista
            return new List<ModalidadeCurva>();
        }

        public RelatorioDadosCurvaSaida ConsultarRelatorioDadosCurva(Curva curva)
        {
            RelatorioDadosCurvaSaida relatorioTemp = null;
            List<TaxaPontoCurvaVigenteRelatorio> listaTaxaPontoCurvaVigente = null;
            DataSet ds;
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                relatorioTemp = new RelatorioDadosCurvaSaida();
                relatorioTemp.Curva = curva.CodigoCurva;

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", relatorioTemp.Curva, DbType.Int32));
                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_INRN_CURV", DbType.String, 15));
                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_CURV", DbType.String, 80));
                data.ParameterOut.Add(new ParameterOutWrapper("@DES_CURV", DbType.String, 120));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODA_CURV", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CATE_MERC", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_SITU", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_CURV", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_SUB_MESA_OPER", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MESA_OPER_TES", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@QTD_ANO_EXTE", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@DAT_ULTI_ALTE", DbType.DateTime, 26));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_LIBE_AUTA", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMTE_VERS", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_TRCI_CURV", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_CURV_PAD", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CLAF_CURV", DbType.Int16, 2));

                ds = data.ExecuteParameterToDataSet("DB2IM.IMSFI");
                //Limpa Lista de Parametros
                data.ParameterIn.Clear();
                data.ParameterOut.Clear();

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    EntidadeFactory.getObterCurvaRelatorio(ds.Tables[0].Rows[0], relatorioTemp);

                    if (relatorioTemp != null)
                    {
                        //Parametro de Entrada 
                        data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", relatorioTemp.Curva, DbType.Int32));
                        data.ParameterOut.Add(new ParameterOutWrapper("@DAT_INCU_VIGE", DbType.DateTime, 26));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODE_CALC", DbType.Int32, 4));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_ENTR_DADO", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_PRZ", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_PRZ_ENTR", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_MOED", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_TXA", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODE_INTV_TOLE", DbType.Int32, 4));
                        data.ParameterOut.Add(new ParameterOutWrapper("@DAT_INIO_CURV_VIGE", DbType.DateTime, 26));
                        data.ParameterOut.Add(new ParameterOutWrapper("@DAT_FIM_CURV_VIGE", DbType.DateTime, 26));
                        data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMRO_FATR_1", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_CURV_BASE_PMT", DbType.Int32, 4));
                        data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMRO_LIBR_DFL", DbType.Int16, 2));


                        ds = data.ExecuteParameterToDataSet("DB2IM.IMS10");
                        //Limpa Lista de Parametros
                        data.ParameterIn.Clear();
                        data.ParameterOut.Clear();

                        //Verifica se é válido
                        if (ds != null && ds.Tables.Count > 0
                            && ds.Tables[0].Rows.Count > 0)
                        {
                            //Adiciona os valores no objeto
                            EntidadeFactory.getCurvaVigenteRelatorio(ds.Tables[0].Rows[0], relatorioTemp);
                        }

                        if (relatorioTemp.DataInclusao != null)
                        {

                            data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", relatorioTemp.Curva, DbType.Int32));
                            data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", relatorioTemp.DataInclusao, DbType.DateTime));

                            ds = data.ExecuteDataSet("DB2IM.IMSEK");

                            data.ParameterIn.Clear();
                            data.ParameterOut.Clear();

                            if (ds != null && ds.Tables.Count > 0)
                            {
                                listaTaxaPontoCurvaVigente = new List<TaxaPontoCurvaVigenteRelatorio>();

                                foreach (DataRow linha in ds.Tables[0].Rows)
                                {
                                    listaTaxaPontoCurvaVigente.Add(EntidadeFactory.getTaxaPontoCurvaVigenteRelatorio(linha));
                                }

                                //Configura o retorno
                                relatorioTemp.lstTaxaPontoCurvaVigente = listaTaxaPontoCurvaVigente;
                            }


                            data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", relatorioTemp.Curva, DbType.Int32));
                            data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", relatorioTemp.DataInclusao, DbType.DateTime));
                            data.ParameterOut.Add(new ParameterOutWrapper("@COD_CURV_SUCE", DbType.Int32, 4));

                            ds = data.ExecuteParameterToDataSet("DB2IM.IMS41");

                            //Limpa Lista de Parametros
                            data.ParameterIn.Clear();
                            data.ParameterOut.Clear();

                            if (ds != null && ds.Tables.Count > 0
                                && ds.Tables[0].Rows.Count > 0)
                            {
                                //Adiciona os valores no objeto
                                EntidadeFactory.getCurvaSucessoraRelatorio(ds.Tables[0].Rows[0], relatorioTemp);
                            }

                            #region Tunelamento

                            data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_INTV_TOL", relatorioTemp.CodigoTunelamento, DbType.Int32));
                            data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_INTV_TOL", DbType.Int16, 2));
                            data.ParameterOut.Add(new ParameterOutWrapper("@COD_ACAO_RETE", DbType.Int16, 2));
                            data.ParameterOut.Add(new ParameterOutWrapper("@NOM_MODE_INTV_TOL", DbType.String, 30));
                            data.ParameterOut.Add(new ParameterOutWrapper("@DES_MODE_INTV_TOL", DbType.String, 100));

                            //Recupera a consulta
                            ds = data.ExecuteParameterToDataSet("DB2IM.IMS08");

                            //Limpa Lista de Parametros
                            data.ParameterIn.Clear();
                            data.ParameterOut.Clear();

                            //Verifica se é válido o retorno
                            if (ds != null && ds.Tables.Count > 0
                                && ds.Tables[0].Rows.Count > 0)
                                EntidadeFactory.getTunelamentoRelatorio(ds.Tables[0].Rows[0], relatorioTemp);

                            #endregion
                        }

                    }
                }

                return relatorioTemp;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }

            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }

            finally
            {
                //Desaloca o objeto
                data.Dispose();
                data = null;
                ds = null;
            }

            return null;
        }

        public IList<TaxaPontoCurva> ObterVerticesInterpolacao()
        {
            List<TaxaPontoCurva> lista = new List<TaxaPontoCurva>();
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("WCOD_TIPO_PONT_CU", 4, DbType.Int16));
                DataSet ds = data.ExecuteDataSet("DB2IM.IMSIR");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getTaxaPontoCurvaRelatorio(linha));
                    }
                }

                //Retorna a consulta
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Finaliza os objetos
                lista = null;
                data.Dispose();
                data = null;
            }

            //Retorna
            return new List<TaxaPontoCurva>();

        }

        public IList<TaxaPontoCurva> ObterMetodosAntepolacao()
        {
            //Declara e instancia o objeto
            List<TaxaPontoCurva> lista = new List<TaxaPontoCurva>();
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                //Código 1 - antepolação
                data.ParameterIn.Add(new ParameterInWrapper("WCOD_TIPO_PONT_CU", 1, DbType.Int16));
                ds = data.ExecuteDataSet("DB2IM.IMSIR");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getTaxaPontoCurvaRelatorio(linha));
                    }
                }
                //Retorna a consulta
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Desaloca os objetos
                data.Dispose();
                data = null;
                ds = null;
                lista = null;
            }

            //Retorna a consulta
            return new List<TaxaPontoCurva>();

        }

        public IList<TaxaPontoCurva> ObterMetodosInterpolacao()
        {
            //Declara e instancia o objeto
            List<TaxaPontoCurva> listaRetorno = new List<TaxaPontoCurva>();
            IDataAccessWrapper data = null;
            DataSet dsRetorno;
            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //TODO:aguardando definicao de proc a ser utilizada
                //Recupera a consulta
                //Código 2 - interpolação
                data.ParameterIn.Add(new ParameterInWrapper("WCOD_TIPO_PONT_CU", 2, DbType.Int16));
                dsRetorno = data.ExecuteDataSet("DB2IM.IMSIR");

                //Verifica se é válido o retorno
                if (dsRetorno.Tables.Count > 0 && dsRetorno.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in dsRetorno.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        listaRetorno.Add(EntidadeFactory.getTaxaPontoCurvaRelatorio(linha));
                    }
                }

                //Retorna a consulta
                return listaRetorno;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Desaloca os objetos
                listaRetorno = null;
                data.Dispose();
                data = null;
                dsRetorno = null;
            }

            //Retorna a consulta limpa
            return new List<TaxaPontoCurva>();

        }

        public IList<TaxaPontoCurva> ObterMetodosExtrapolacao()
        {
            //Declara e instancia o objeto
            List<TaxaPontoCurva> lista = new List<TaxaPontoCurva>();
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                //Código 3 - interpolação
                data.ParameterIn.Add(new ParameterInWrapper("WCOD_TIPO_PONT_CU", 3, DbType.Int16));
                ds = data.ExecuteDataSet("DB2IM.IMSIR");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getTaxaPontoCurvaRelatorio(linha));
                    }
                }

                //Retorna a consulta
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }

            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }

            finally
            {
                //Desaloca o objeto
                lista = null;
                data.Dispose();
                data = null;
                ds = null;
            }

            //Retorna a consulta
            return new List<TaxaPontoCurva>();
        }

        public IList<Moeda> ObterMoedas()
        {
            //Declara e instancia o objeto
            List<Moeda> lista = new List<Moeda>();
            IDataAccessWrapper data = null;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                DataSet ds = data.ExecuteDataSet("DB2IM.IMSIH");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getMoedaRelatorio(linha));
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }

            //Retorna a consulta
            return lista;
        }

        public IList<TipoPrazo> ObterTiposPrazo()
        {
            List<TipoPrazo> lista = new List<TipoPrazo>();
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                DataSet ds = data.ExecuteDataSet("DB2IM.IMSIJ");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getTipoPrazoRelatorio(linha));
                    }
                }

                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
                //Desaloca o objeto
                lista = null;
            }

            //Retorna a consulta
            return new List<TipoPrazo>();
        }

        public IList<TipoTaxa> ObterTiposTaxa()
        {
            List<TipoTaxa> lista = new List<TipoTaxa>();
            IDataAccessWrapper data = null;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                //DataSet ds = data.ExecuteDataSet("DB2IM.IMSIK");
                //Código 5 - interpolação
                data.ParameterIn.Add(new ParameterInWrapper("WCOD_TIPO_PONT_CU", 5, DbType.Int16));
                DataSet ds = data.ExecuteDataSet("DB2IM.IMSIR");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getTipoTaxaRelatorio(linha));
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }

            //Retorna a consulta
            return lista;
        }

        public IList<CategoriaMercado> ObterCategoriasMercado()
        {
            //Declara e instancia o objeto
            List<CategoriaMercado> listaRetorno = new List<CategoriaMercado>();
            IDataAccessWrapper data = null;
            DataSet dsRetorno;
            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                dsRetorno = data.ExecuteDataSet("DB2IM.IMSIG");

                //Verifica se é válido o retorno
                if (dsRetorno.Tables.Count > 0 && dsRetorno.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in dsRetorno.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        listaRetorno.Add(EntidadeFactory.getCategoriaMercadoRelatorio(linha));
                    }
                }

                //Retorna a consulta
                return listaRetorno;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                //Desaloca os objetos
                listaRetorno = null;
                data.Dispose();
                data = null;
                dsRetorno = null;
            }

            //Retorna a consulta limpa
            return new List<CategoriaMercado>();

        }

        public IList<Situacao> ObterSituacoes()
        {
            List<Situacao> lista = new List<Situacao>();
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                ds = data.ExecuteDataSet("DB2IM.IMSIM");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getSituacao(linha));
                    }
                }

                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                lista = null;
                data.Dispose();
                data = null;
                ds = null;
            }

            return new List<Situacao>();
        }

        public IList<SubMesaOperacao> ObterSubMesas(int codigoMesa)
        {
            //Declara e instancia o objeto
            List<SubMesaOperacao> lista = new List<SubMesaOperacao>();
            IDataAccessWrapper data = null;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Parametro de Entrada
                data.ParameterIn.Add(new ParameterInWrapper("@COD_MESA_OPER_TES", codigoMesa, DbType.Int16));

                //Recupera a consulta
                DataSet ds = data.ExecuteDataSet("DB2IM.IMSGX");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getSubMesaOperacao(linha));
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }

            //Retorna a consulta
            return lista;
        }

        public Curva ObterCurva(int curvaID)
        {
            Curva objCurva = null;
            DataSet ds;
            IDataAccessWrapper data = null;
            List<TaxaPontoCurvaVigenteRelatorio> listaTaxaPontoCurvaVigente;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_INRN_CURV", DbType.String, 15));
                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_CURV", DbType.String, 80));
                data.ParameterOut.Add(new ParameterOutWrapper("@DES_CURV", DbType.String, 120));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODA_CURV", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CATE_MERC", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_SITU", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_CURV", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_SUB_MESA_OPER", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MESA_OPER_TES", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@QTD_ANO_EXTE", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@DAT_ULTI_ALTE", DbType.DateTime, 26));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_LIBE_AUTA", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMTE_VERS", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_TRCI_CURV", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_CURV_PAD", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CLAF_CURV", DbType.Int16, 2));

                ds = data.ExecuteParameterToDataSet("DB2IM.IMSFI");
                //Limpa Lista de Parametros
                data.ParameterIn.Clear();
                data.ParameterOut.Clear();

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Adiciona os valores no objeto
                    objCurva = EntidadeFactory.getObterCurva(ds.Tables[0].Rows[0]);

                    //Verifica se é válido
                    if (objCurva != null)
                    {
                        //Parametro de Entrada 
                        data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                        data.ParameterOut.Add(new ParameterOutWrapper("@DAT_INCU_VIGE", DbType.DateTime, 26));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODE_CALC", DbType.Int32, 4));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_ENTR_DADO", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_PRZ", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_PRZ_ENTR", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_MOED", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_TXA", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODE_INTV_TOLE", DbType.Int32, 4));
                        data.ParameterOut.Add(new ParameterOutWrapper("@DAT_INIO_CURV_VIGE", DbType.DateTime, 26));
                        data.ParameterOut.Add(new ParameterOutWrapper("@DAT_FIM_CURV_VIGE", DbType.DateTime, 26));
                        data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMRO_FATR_1", DbType.Int16, 2));
                        data.ParameterOut.Add(new ParameterOutWrapper("@COD_CURV_BASE_PMT", DbType.Int32, 4));
                        data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMRO_LIBR_DFL", DbType.Int16, 2));

                        //Recupera a consulta
                        ds = data.ExecuteParameterToDataSet("DB2IM.IMS10");
                        //Limpa Lista de Parametros
                        data.ParameterIn.Clear();
                        data.ParameterOut.Clear();

                        //Verifica se é válido
                        if (ds != null && ds.Tables.Count > 0
                            && ds.Tables[0].Rows.Count > 0)
                        {
                            //Adiciona os valores no objeto
                            objCurva.CurvaVigente = EntidadeFactory.getCurvaVigente(ds.Tables[0].Rows[0]);

                            //Segundo a orientação da Aleksandra, codigo Praça Calendario fixo 1
                            objCurva.CurvaVigente.CodigoPraca = 1;
                        }

                        //Verifica se é válido
                        if (objCurva.CurvaVigente != null)
                        {
                            //Parametro de Entrada 
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                            data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", objCurva.CurvaVigente.DataInclusao, DbType.DateTime));

                            //Recupera a consulta
                            ds = data.ExecuteDataSet("DB2IM.IMSEK");

                            //Limpa Lista de Parametros
                            data.ParameterIn.Clear();
                            data.ParameterOut.Clear();

                            if (ds != null && ds.Tables.Count > 0)
                            {
                                //Instância a lista
                                listaTaxaPontoCurvaVigente = new List<TaxaPontoCurvaVigenteRelatorio>();

                                //Percorre todos os registros da tabela
                                foreach (DataRow linha in ds.Tables[0].Rows)
                                {
                                    //Adiciona os valores no objeto
                                    listaTaxaPontoCurvaVigente.Add(EntidadeFactory.getTaxaPontoCurvaVigente(linha));
                                }

                                //Configura o retorno
                                objCurva.CurvaVigente.lstTaxaPontoCurvaVigente = listaTaxaPontoCurvaVigente;
                            }

                            //Parametro de Entrada 
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                            data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", objCurva.CurvaVigente.DataInclusao, DbType.DateTime));
                            data.ParameterOut.Add(new ParameterOutWrapper("@COD_CURV_SUCE", DbType.Int32, 4));

                            //Recupera a consulta
                            ds = data.ExecuteParameterToDataSet("DB2IM.IMS41");

                            //Limpa Lista de Parametros
                            data.ParameterIn.Clear();
                            data.ParameterOut.Clear();

                            //Verifica se é válido o retorno
                            if (ds != null && ds.Tables.Count > 0
                                && ds.Tables[0].Rows.Count > 0)
                            {
                                //Adiciona os valores no objeto
                                objCurva.CurvaVigente.CurvaSucessora = (EntidadeFactory.getCurvaSucessora(ds.Tables[0].Rows[0]));
                            }

                            //Verifica se é válido
                            if (objCurva.CurvaVigente.CurvaSucessora != null)
                            {
                                //Parametro de Entrada 
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", objCurva.CurvaVigente.CurvaSucessora.CodigoCurvaSucessora, DbType.Int32));
                                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_INRN_CURV", DbType.String, 15));
                                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_CURV", DbType.String, 80));
                                data.ParameterOut.Add(new ParameterOutWrapper("@DES_CURV", DbType.String, 120));
                                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MODA_CURV", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CATE_MERC", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@COD_SITU", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_CURV", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@COD_SUB_MESA_OPER", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@COD_MESA_OPER_TES", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@QTD_ANO_EXTE", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@DAT_ULTI_ALTE", DbType.DateTime, 26));
                                data.ParameterOut.Add(new ParameterOutWrapper("@IND_LIBE_AUTA", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@IND_PMTE_VERS", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@IND_TRCI_CURV", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_CURV_PAD", DbType.Int16, 2));
                                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CLAF_CURV", DbType.Int16, 2));

                                //Recupera a consulta
                                ds = data.ExecuteParameterToDataSet("DB2IM.IMSFI");

                                //Limpa Lista de Parametros
                                data.ParameterIn.Clear();
                                data.ParameterOut.Clear();

                                //Verifica se é válido o retorno
                                if (ds != null && ds.Tables.Count > 0
                                    && ds.Tables[0].Rows.Count > 0)
                                {
                                    Curva curva = EntidadeFactory.getObterCurva(ds.Tables[0].Rows[0]);
                                    CurvaSucessora curvaSucessora = new CurvaSucessora();
                                    curvaSucessora.CodigoCurva = curva.CodigoCurva;
                                    curvaSucessora.NomeCurva = curva.NomeCurva;
                                    objCurva.CurvaVigente.Curva = curvaSucessora;

                                    //Adiciona os valores no objeto
                                    // TODO remover
                                    //objCurva.CurvaVigente.Curva.CodigoCurva = Convert.ToInt32(ds.Tables[0].Rows[0]["COD_CURV"]);
                                }
                            }

                            //Carrega dados de curva composta
                            if (objCurva.CurvaVigente.CodigoTipoEntradaDado == 1)
                            {
                                //Parametro de Entrada 
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", objCurva.CurvaVigente.DataInclusao, DbType.DateTime));
                                data.ParameterOut.Add(new ParameterOutWrapper("@DES_FORU_CPSC", DbType.String, 100));

                                //Recupera a consulta
                                ds = data.ExecuteParameterToDataSet("DB2IM.IMSIV");

                                //Limpa Lista de Parametros
                                data.ParameterIn.Clear();
                                data.ParameterOut.Clear();

                                //Verifica se é válido o retorno
                                if (ds != null && ds.Tables.Count > 0
                                    && ds.Tables[0].Rows.Count > 0)
                                    //Recupera o objeto
                                    objCurva.CurvaVigente.ComposicaoCurva = EntidadeFactory.getComposicaoCurva(ds.Tables[0].Rows[0]);

                            }

                            //Parametro de Entrada 
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                            data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_EXEO_GRD", DbType.Int16, 2));
                            data.ParameterOut.Add(new ParameterOutWrapper("@HOR_INIO", DbType.Time, 8));
                            data.ParameterOut.Add(new ParameterOutWrapper("@HOR_FIM", DbType.Time, 8));
                            data.ParameterOut.Add(new ParameterOutWrapper("@QTD_TEMP", DbType.Int16, 2));
                            data.ParameterOut.Add(new ParameterOutWrapper("@COD_UNID_TEMP", DbType.Int16, 2));

                            //Recupera a consulta
                            ds = data.ExecuteParameterToDataSet("DB2IM.IMSEV");
                            //Limpa Lista de Parametros
                            data.ParameterIn.Clear();
                            data.ParameterOut.Clear();

                            if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                            {
                                //Adiciona os valores no objeto
                                objCurva.GradeExecucaoCurva = EntidadeFactory.getGradeExecucaoCurva(ds.Tables[0].Rows[0]);
                            }

                            //Veririfica se é válido
                            if (objCurva.GradeExecucaoCurva != null)
                            {
                                //Parametro de Entrada 
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));

                                //Recupera a consulta
                                ds = data.ExecuteDataSet("DB2IM.IMSEW");

                                //Limpa Lista de Parametros
                                data.ParameterIn.Clear();
                                data.ParameterOut.Clear();

                                //Instância a lista
                                objCurva.GradeExecucaoCurva.registroGradeExecucaoCurva = new List<RegistroGradeExecucaoCurva>();

                                if (ds.Tables.Count > 0)
                                {
                                    //Percorre todos os registros da tabela
                                    foreach (DataRow linha in ds.Tables[0].Rows)
                                    {
                                        //Recupera os itens
                                        objCurva.GradeExecucaoCurva.registroGradeExecucaoCurva.Add(EntidadeFactory.getRegistroGradeExecucaoCurva(linha));
                                    }
                                }
                            }

                            //Verifica se é válido
                            if (objCurva.CurvaVigente.ComposicaoCurva != null)
                            {

                                //Parametro de Entrada 
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", objCurva.CurvaVigente.DataInclusao, DbType.DateTime));

                                //Recupera a consulta
                                ds = data.ExecuteDataSet("DB2IM.IMSIW");

                                //Limpa Lista de Parametros
                                data.ParameterIn.Clear();
                                data.ParameterOut.Clear();

                                //Instância a lista
                                objCurva.CurvaVigente.ComposicaoCurva.Itens = new List<ItemComposicao>();

                                if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                                {

                                    //Percorre todos os registros da tabela
                                    foreach (DataRow linha in ds.Tables[0].Rows)
                                    {
                                        //Adiciona o item
                                        objCurva.CurvaVigente.ComposicaoCurva.Itens.Add(EntidadeFactory.getItemComposicaoCurva(linha));
                                    }
                                }
                            }

                            //Carrega dados de importacao de arquivo
                            if (objCurva.CurvaVigente.CodigoTipoEntradaDado == 3)
                            {
                                //Parametro de Entrada 
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_CURV", curvaID, DbType.Int32));
                                data.ParameterIn.Add(new ParameterInWrapper("@DAT_INCU_VIGE", objCurva.CurvaVigente.DataInclusao, DbType.DateTime));
                                data.ParameterOut.Add(new ParameterOutWrapper("@SIG_TIPO_ARQU", DbType.String, 4));
                                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_DRTO", DbType.String, 100));
                                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_ARQU", DbType.String, 30));
                                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_PNLH", DbType.String, 30));
                                data.ParameterOut.Add(new ParameterOutWrapper("@IND_VLDO_DAT_RFRC", DbType.String, 1));
                                data.ParameterOut.Add(new ParameterOutWrapper("@IND_VLDO_NOM_ARQU", DbType.String, 1));

                                //Recupera a consulta
                                ds = data.ExecuteParameterToDataSet("DB2IM.IM0SPB");

                                //Limpa Lista de Parametros
                                data.ParameterIn.Clear();
                                data.ParameterOut.Clear();

                                //Verifica se é válido o retorno
                                if (ds != null && ds.Tables.Count > 0
                                    && ds.Tables[0].Rows.Count > 0)
                                    //Recupera o objeto
                                    objCurva.CurvaVigente.ImportacaoArquivo = EntidadeFactory.getImportacaoArquivo(ds.Tables[0].Rows[0]);

                            }

                            //Parametro de Entrada                             
                            data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_INTV_TOL", objCurva.CurvaVigente.CodigoModeloIntervaloTolerancia, DbType.Int32));
                            data.ParameterOut.Add(new ParameterOutWrapper("@COD_TIPO_INTV_TOL", DbType.Int16, 2));
                            data.ParameterOut.Add(new ParameterOutWrapper("@COD_ACAO_RETE", DbType.Int16, 2));
                            data.ParameterOut.Add(new ParameterOutWrapper("@NOM_MODE_INTV_TOL", DbType.String, 30));
                            data.ParameterOut.Add(new ParameterOutWrapper("@DES_MODE_INTV_TOL", DbType.String, 100));

                            //Recupera a consulta
                            ds = data.ExecuteParameterToDataSet("DB2IM.IMS08");

                            //Limpa Lista de Parametros
                            data.ParameterIn.Clear();
                            data.ParameterOut.Clear();

                            //Verifica se é válido o retorno
                            if (ds != null && ds.Tables.Count > 0
                                && ds.Tables[0].Rows.Count > 0)
                                //Recupera o objeto
                                objCurva.CurvaVigente.ModeloIntervaloTolerancia = EntidadeFactory.getModeloIntervaloToleranciaParametro(ds.Tables[0].Rows[0]);


                            //Verifica se é válida
                            if (objCurva.CurvaVigente.ModeloIntervaloTolerancia != null)
                            {
                                //Parametro de Entrada 
                                data.ParameterIn.Add(new ParameterInWrapper("@COD_MODE_INTV_TOL", objCurva.CurvaVigente.CodigoModeloIntervaloTolerancia, DbType.Int32));

                                //Recupera a consulta
                                ds = data.ExecuteDataSet("DB2IM.IMS07");

                                //Limpa Lista de Parametros
                                data.ParameterIn.Clear();

                                //Instância a lista de saída
                                objCurva.CurvaVigente.ModeloIntervaloTolerancia.lstParametroModeloIntervaloTolerancia = new List<ParametroModeloIntervaloTolerancia>();

                                //Percorre todos os registros da tabela
                                foreach (DataRow linha in ds.Tables[0].Rows)
                                {
                                    //Adiciona o item
                                    objCurva.CurvaVigente.ModeloIntervaloTolerancia.lstParametroModeloIntervaloTolerancia.Add(EntidadeFactory.getParametroModeloIntervaloTolerancia(linha));

                                }
                            }
                        }

                        //Retorna a consulta
                        return objCurva;
                    }
                }

            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }

            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }

            finally
            {
                //Desaloca o objeto
                objCurva = null;
                data.Dispose();
                data = null;
                ds = null;
                listaTaxaPontoCurvaVigente = null;
            }

            return new Curva();
        }

        public IList<ModeloCalculo> ObterModelosCalculo()
        {
            //Declara e instancia o objeto
            List<ModeloCalculo> lista = new List<ModeloCalculo>();
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                //Recupera o objeto de acesso a dados
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Recupera a consulta
                ds = data.ExecuteDataSet("DB2IM.IMSII");

                //Verifica se é válido o retorno
                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    //Percorre todos os registros da tabela
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        //Monta e adiciona o objeto na lista
                        lista.Add(EntidadeFactory.getModeloCalculo(linha));
                    }
                }
                //Retorna a consulta
                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
                ds = null;
                lista = null;
            }

            //Retorna a consulta
            return new List<ModeloCalculo>();
        }
    }
}
